home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gdevln03.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-14  |  11.2 KB  |  371 lines
  1. /* Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYLEFT.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /*
  20. gdevln03.c
  21. Ghostscript driver for DEC LN03 printer
  22.  
  23. Ulrich Mueller, Div. PPE, CERN, CH-1211 Geneva 23 <ulm@vsnhd1.cern.ch>
  24. This code is subject to the GNU General Public License
  25.  
  26. ulm 91-02-13 created as driver for gs 2.1.1
  27. ulm 91-07-23 adapted to gs 2.2
  28. ulm 91-08-21 changed memory allocation to gs_malloc,
  29.          ported to VMS (contributed by Martin Stiftinger, TU Vienna)
  30. lpd 91-11-24 sped up by removing multiplies from inner loop
  31. ijmp 92-04-14 add support for la75/la50 (macphed@dvinci.usask.ca)
  32. ulm 92-09-25 support letter size paper (8.5" x 11")
  33. bbl 93-06-10 added la70 mode (bruce@csugrad.cs.vt.edu)
  34. lpd/ab 94-02-04 added la75plus mode (Andre_Beck@IRS.Inf.TU-Dresden.de)
  35. pbk 94-02-28 keep lines less than 80 chars for systems where files
  36.              typed to terminal don't work otherwise; define separate
  37.              eject string for each device for flexibility;
  38.              add support for CRT sixels (keegstra@tonga.gsfc.nasa.gov)
  39. */
  40.  
  41. #include "gdevprn.h"
  42.  
  43. /* Forward references */
  44. private int sixel_print_page(P4(gx_device_printer *pdev, FILE *prn_stream,
  45.                                 const char *init, const char *eject));
  46.  
  47. /* The device descriptor */
  48. private dev_proc_output_page(sixel_output_page);
  49. private dev_proc_print_page(ln03_print_page);
  50. /* We have to supply our own procs, since we have to intercept */
  51. /* output_page so we can open the printer in text mode. */
  52. private gx_device_procs sixel_procs =
  53.   prn_procs(gdev_prn_open, sixel_output_page, gdev_prn_close);
  54.  
  55. #ifdef A4
  56. #  define BOTTOM_MARGIN 0.5
  57. #else
  58. #  define BOTTOM_MARGIN 0.4
  59. #endif
  60. gx_device_printer gs_ln03_device =
  61.     prn_device(sixel_procs, "ln03",
  62.            DEFAULT_WIDTH_10THS, DEFAULT_HEIGHT_10THS,
  63.            300, 300,        /* x_dpi, y_dpi */
  64.            0, BOTTOM_MARGIN, 0, 0,    /* left, bottom, right, top margin */
  65.            1, ln03_print_page);
  66.  
  67. /*
  68.  * Initialization string: switch to graphics mode, 300 dpi
  69.  * <ESC>[!p        DECSTR    soft terminal reset
  70.  * <ESC>[11h        PUM        select unit of measurement
  71.  * <ESC>[7 I        SSU        select pixel as size unit
  72.  * <ESC>[?52h        DECOPM    origin is upper-left corner
  73.  * <ESC>[0t        DECSLPP    set maximum form length
  74.  * <ESC>[1;2475s    DECSLRM    set left and right margins
  75.  * <ESC>P0;0;1q            select sixel graphics mode
  76.  * "1;1            DECGRA    aspect ratio (1:1)
  77.  */
  78.  
  79. #define LN03_INIT \
  80.  "\033[!p\033[11h\033[7 I\033[?52h\033[0t\033[1;2475s\033P0;0;1q\"1;1"
  81.  
  82. /* leave sixel graphics mode, eject page
  83.       <ESC>\        ST    string terminator
  84.       <FF>        FF    form feed */
  85. #define LN03_EJECT "\033\\\f"
  86.  
  87. private int
  88. ln03_print_page(gx_device_printer *pdev, FILE *prn_stream)
  89. {
  90.     return (sixel_print_page(pdev,prn_stream,LN03_INIT,LN03_EJECT));
  91. }
  92.  
  93. /*
  94.  * LA50 dot matrix printer device.
  95.  * This uses North American 8.5 x 11 inch paper size.
  96.  */
  97. private dev_proc_print_page(la50_print_page);
  98. gx_device_printer gs_la50_device =
  99.     prn_device(sixel_procs, "la50",
  100.            85,
  101.            110,
  102.            144, 72,
  103.            0, 0, 0.5, 0,
  104.            1, la50_print_page);
  105. /* LA50's use a very primitive form of initialization */
  106.  
  107. #define LA50_INIT "\033Pq"
  108.  
  109. /* leave sixel graphics mode, eject page
  110.       <ESC>\        ST    string terminator
  111.       <FF>        FF    form feed */
  112. #define LA50_EJECT "\033\\\f"
  113.  
  114. private int
  115. la50_print_page(gx_device_printer *pdev, FILE *prn_stream)
  116. {
  117.     return (sixel_print_page(pdev,prn_stream,LA50_INIT,LA50_EJECT));
  118. }
  119.  
  120. /*
  121.  * LA70 dot matrix printer device.
  122.  * This uses North American 8.5 x 11 inch paper size.
  123.  */
  124. private dev_proc_print_page(la70_print_page);
  125. gx_device_printer gs_la70_device =
  126.     prn_device(sixel_procs, "la70",
  127.            85,
  128.            110,
  129.            144, 144,
  130.            0, 0, 0.5, 0,
  131.            1, la70_print_page);
  132.  
  133. #define LA70_INIT "\033P0;0;0q\"1;1"
  134.  
  135. /* leave sixel graphics mode, eject page
  136.       <ESC>\        ST    string terminator
  137.       <FF>        FF    form feed */
  138. #define LA70_EJECT "\033\\\f"
  139.  
  140. private int
  141. la70_print_page(gx_device_printer *pdev, FILE *prn_stream)
  142. {
  143.     return (sixel_print_page(pdev,prn_stream,LA70_INIT,LA70_EJECT));
  144. }
  145.  
  146. /*
  147.  * LA75 dot matrix printer device.
  148.  * This uses North American 8.5 x 11 inch paper size.
  149.  */
  150. private dev_proc_print_page(la75_print_page);
  151. gx_device_printer gs_la75_device =
  152.     prn_device(sixel_procs, "la75",
  153.            85,
  154.            110,
  155.            144, 72,
  156.            0, 0, 0.5, 0,
  157.            1, la75_print_page);
  158.  
  159. #define LA75_INIT "\033P0;0;0q"
  160.  
  161. /* leave sixel graphics mode, eject page
  162.       <ESC>\        ST    string terminator
  163.       <FF>        FF    form feed */
  164. #define LA75_EJECT "\033\\\f"
  165.  
  166. private int
  167. la75_print_page(gx_device_printer *pdev, FILE *prn_stream)
  168. {
  169.     return (sixel_print_page(pdev,prn_stream,LA75_INIT,LA75_EJECT));
  170. }
  171.  
  172. /*
  173.  * LA75+ dot matrix printer device (24 needles).
  174.  * This uses either A4 or US paper size.
  175.  * Last changed: 03.02.94 -abp
  176.  */
  177. private dev_proc_print_page(la75plus_print_page);
  178. gx_device_printer gs_la75plus_device =
  179.     prn_device(sixel_procs, "la75plus",
  180.                85,
  181.                110,
  182.                180, 180,
  183.                0, 0, BOTTOM_MARGIN, 0,
  184.                1, la75plus_print_page);
  185.  
  186. /*
  187.  * Init String:
  188.  * <ESC>c               full reset
  189.  * <DCS>0;0;1q          start sixel printing at max resolution
  190.  * "1;1                 aspect ratio 1:1
  191.  */
  192.  
  193. #define LA75PLUS_INIT "\033c\033P0;0;1q\"1;1"
  194.  
  195. /* leave sixel graphics mode, eject page
  196.       <ESC>\        ST    string terminator
  197.       <FF>        FF    form feed */
  198. #define LA75PLUS_EJECT "\033\\\f"
  199.  
  200. private int
  201. la75plus_print_page(gx_device_printer *pdev, FILE *prn_stream)
  202. {
  203.     return (sixel_print_page(pdev,prn_stream,LA75PLUS_INIT,LA75PLUS_EJECT));
  204. }
  205.  
  206. /*
  207.  * CRT sixels, e.g. for display by VT240-like terminals or MSKERMIT.
  208.  * Parameters set so MSKERMIT using sixels matches native EGA.
  209.  * COBE/DMR prefers (145, 100, 56.8, 28.5) to match its program DPSI.
  210.  */
  211. private dev_proc_print_page(sxlcrt_print_page);
  212. gx_device_printer gs_sxlcrt_device =
  213.     prn_device(sixel_procs,
  214.                "sxlcrt",
  215.                180,
  216.                110,
  217.                42.6667, 32.0,
  218.                0, 0, 0, 0,
  219.                1, sxlcrt_print_page);
  220.  
  221. /* Use init and eject strings similar to COBE/DMR program DQUSIXEL */
  222. /* Add an exit Tek emulation sequence so kermit displays properly  */
  223. #define SXLCRT_INIT "\033[?38l\033P0q"
  224. /* leave sixel graphics mode, home cursor */
  225. #define SXLCRT_EJECT "\033\\\033[23;0H"
  226.  
  227. private int
  228. sxlcrt_print_page(gx_device_printer *pdev, FILE *prn_stream)
  229. {
  230.     return (sixel_print_page(pdev,prn_stream,SXLCRT_INIT,SXLCRT_EJECT));
  231. }
  232.  
  233. /* ------ Internal routines ------ */
  234.  
  235. /* Open the printer in text mode before gdev_prn_output_page */
  236. /* opens it in binary mode. */
  237. private int
  238. sixel_output_page(gx_device *pdev, int num_copies, int flush)
  239. {    int code = gdev_prn_open_printer(pdev, 0);
  240.     if ( code < 0 )
  241.         return code;
  242.     return gdev_prn_output_page(pdev, num_copies, flush);
  243. }
  244.  
  245. /* Send the page to the printer. */
  246. /* Keep all lines <= 80 chars */
  247. private int
  248. sixel_print_page(gx_device_printer *pdev, FILE *prn_stream,
  249.                  const char *init, const char *eject)
  250. {
  251.     byte *in, *inp;
  252.     int lnum, lcount, l, count, empty, mask, c, oldc, line_size, in_size;
  253.     int ccount;
  254.  
  255.     line_size = gdev_mem_bytes_per_scan_line((gx_device *)pdev);
  256.     in_size = line_size * 6;
  257.     in = (byte *)gs_malloc(in_size, 1, "sixel_print_page");
  258.  
  259.     /* Check allocation */
  260.     if (!in) return(-1);
  261.  
  262.     fputs(init,prn_stream);
  263.     ccount = strlen(init);
  264.  
  265.     /* Print lines of graphics */
  266.     for (lnum = lcount = 0; lnum < pdev->height; lnum+=6, lcount++) {
  267.     gdev_prn_copy_scan_lines(pdev, lnum, inp = in, line_size * 6);
  268.  
  269.     mask = 0200;
  270.     oldc = 077;
  271.     empty = 1;
  272.  
  273.     for (l = pdev->width, count = 0; --l >= 0; count++) {
  274.         /* transpose 6*8 rectangle */
  275.         register byte *iptr = inp;
  276.         c = 077;
  277.         if (*iptr & mask)
  278.         c += 1;
  279.         if (*(iptr += line_size) & mask)
  280.         c += 2;
  281.         if (*(iptr += line_size) & mask)
  282.         c += 4;
  283.         if (*(iptr += line_size) & mask)
  284.         c += 010;
  285.         if (*(iptr += line_size) & mask)
  286.         c += 020;
  287.         if (*(iptr += line_size) & mask)
  288.         c += 040;
  289.         if (!(mask >>= 1)) {
  290.         mask = 0200;
  291.         inp++;
  292.         }
  293.  
  294.             if (c != oldc) {
  295.                 if (empty) {
  296.                     while (--lcount >= 0) {
  297.  
  298.                         /* terminate record.
  299.                            this LF is ignored by the LN03 */
  300.                         if (ccount > 78) {
  301.                             fputc('\n', prn_stream);
  302.                             ccount = 0;
  303.                         }
  304.                         /* terminate previous line */
  305.                         fputc('-', prn_stream);
  306.                         ccount++;
  307.                     }
  308.                     empty = lcount = 0;
  309.                 }
  310.                 if (count > 3) {
  311.                     /* use run length encoding */
  312.                     if (ccount > 74) {
  313.                         fputc('\n', prn_stream);
  314.                         ccount = 0;
  315.                     }
  316.                     /* we know lines will not exceed 10000 pixels */
  317.                     ccount = ccount + 3 + (count > 9)
  318.                                         + (count > 99)
  319.                                         + (count > 999);
  320.                     fprintf(prn_stream, "!%d%c", count, oldc);
  321.                 }
  322.                 else {
  323.                     while (--count >= 0) {
  324.                         if (ccount > 78) {
  325.                             fputc('\n', prn_stream);
  326.                             ccount = 0;
  327.                         }
  328.                         fputc(oldc, prn_stream);
  329.                         ccount++;
  330.                     }
  331.                 }
  332.                 oldc = c;
  333.                 count = 0;
  334.             }
  335.         }
  336.         if (c != 077) {
  337.            if (count > 3) {
  338.                 /* use run length encoding */
  339.                 if (ccount > 74) {
  340.                     fputc('\n', prn_stream);
  341.                     ccount = 0;
  342.                 }
  343.                 /* we know lines will not exceed 10000 pixels */
  344.                 ccount = ccount + 3 + (count > 9)
  345.                                     + (count > 99)
  346.                                     + (count > 999);
  347.                 fprintf(prn_stream, "!%d%c", count, c);
  348.             }
  349.             else {
  350.                 while (--count >= 0) {
  351.                     if (ccount > 78) {
  352.                         fputc('\n', prn_stream);
  353.                         ccount = 0;
  354.                     }
  355.                     fputc(c, prn_stream);
  356.                     ccount++;
  357.                 }
  358.             }
  359.         }
  360.     }
  361.  
  362.     /* leave sixel graphics mode, eject page */
  363.     if (ccount + strlen(eject) > 79) fputc('\n', prn_stream);
  364.     fputs(eject, prn_stream);
  365.     fflush(prn_stream);
  366.  
  367.     gs_free((char *)in, in_size, 1, "sixel_print_page");
  368.  
  369.     return(0);
  370. }
  371.